package lambda;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @auther hhh
 * @date 2018/12/28 23:02
 * @description 如果函数式接口的实现恰好可以通过调用一个静态方法来实现，那么就可以使用静态方法引用
 * 语法：类名::staticMethod
 * 注意：
 *      方法的引用不需要括号，因为其仅仅是方法的引用，并没有执行
 *      使用的函数式接口输入输出必须与定义的函数式接口一致
 */
public class StaticMethodUse{
    static <T> String hello(T s) {
        return s.toString();
    }
    static <T> String ret() {
        return "hello";
    }
    static void getSize(String s) {
        System.out.println(s.length());
    }
    static String toUpCase(String s){
        return s.toUpperCase();
    }
    public static void main(String[] args) {
        Supplier<String> supplier = () -> hello("hello");
        System.out.println(supplier);
        //使用方法引用 Supplier T get();
        // 1、只支持输出参数，不支持输入参数，所以一下方法报错
        //2、方法的引用为什么不需要括号?因为其仅仅是方法的引用，并没有执行
        //Supplier<String> stringSupplier = StaticMethodUse::hello("wqer");
        Supplier<String> s = StaticMethodUse::ret;
        Supplier<String> supplier1 = Fun::put;
        Function<Integer, String> function = StaticMethodUse::hello;
        //方法的参数必须在调用的时候传入,必须调用函数式接口
        System.out.println("function" + function.apply(123));

        //普通lambda使用
        Consumer<String> consumer = size -> StaticMethodUse.getSize(size);
        //方法的引用为什么不需要括号?因为其仅仅是方法的引用，并没有执行
        Consumer<String> c1 = StaticMethodUse::getSize;
        c1.accept("hello use lambda");

        //输出参数大写
        Function<String ,String> function1 = (ss) -> ss.toUpperCase();
        Function<String,String> function2 = StaticMethodUse::toUpCase;
        Function<String,String> function3 = Fun::toUpCase;
        System.out.println(function1.apply("aasdf"));
        System.out.println(function2.apply("aasdf"));
        System.out.println(function3.apply("aasdf"));
    }
}

class Fun {
    static String put() {
        return "hello";
    }
    static String toUpCase(String s){
        return s.toUpperCase();
    }
}